/**
 * 路由守卫工具
 * @author Wu.Liang
 * @date 2025-01-21
 */

import { useAuthStore } from '@/store'

/**
 * 路由守卫配置
 */
const routeGuards = {
  // 需要登录的页面
  requireAuth: [
    '/pages/index/index',
    '/pages/profile/index',
    '/pages/services/services',
    '/pages/emergency/emergency',
    '/pages/parking/parking',
    '/pages/property/property',
    '/pages/security/security'
  ],
  
  // 已登录用户不能访问的页面
  guestOnly: [
    '/pages/login/login',
    '/pages/register/register',
    '/pages/login/forgot-password'
  ],
  
  // 需要特定菜单权限的页面 - 移除服务页面和个人中心页面的权限要求
  requireMenuPermission: {
    '/pages/admin/admin': ['admin:menu'],
    '/pages/security/security': ['security:menu']
    // 移除 /pages/property/property 的权限要求，改为检查用户是否关联物业公司
  },
  
  // 需要特定角色的页面
  requireRole: {
    '/pages/admin/admin': ['admin'],
    '/pages/property/property': ['property_manager', 'admin']
  }
}

/**
 * 路由守卫类
 */
class RouterGuard {
  constructor() {
    // 移除构造函数中的store调用，避免在模块加载时就初始化
    this._authStore = null
  }
  
  /**
   * 获取认证store实例
   */
  get authStore() {
    if (!this._authStore) {
      this._authStore = useAuthStore()
    }
    return this._authStore
  }
  
  /**
   * 检查页面访问权限
   * @param {string} url 页面路径
   * @returns {object} 检查结果
   */
  checkAccess(url) {
    const result = {
      canAccess: true,
      redirect: null,
      reason: null
    }
    
    // 检查是否需要登录
    if (this.requireAuth(url) && !this.authStore.isLoggedIn) {
      result.canAccess = false
      result.redirect = '/pages/login/login'
      result.reason = '需要登录'
      return result
    }
    
    // 检查已登录用户不能访问的页面
    if (this.isGuestOnly(url) && this.authStore.isLoggedIn) {
      result.canAccess = false
      result.redirect = '/pages/index/index'
      result.reason = '已登录用户不能访问'
      return result
    }
    
    // 特殊权限检查：物业服务页面
    if (url === '/pages/property/property') {
      // 所有已登录用户都可以访问物业服务页面
      // 移除物业公司关联检查，简化权限控制
      return result
    }
    
    // 检查权限
    if (this.requireMenuPermission(url) && !this.hasMenuPermission(url)) {
      result.canAccess = false
      result.redirect = '/pages/error/403'
      result.reason = '权限不足'
      return result
    }
    
    // 检查角色
    if (this.requireRole(url) && !this.hasRole(url)) {
      result.canAccess = false
      result.redirect = '/pages/error/403'
      result.reason = '角色权限不足'
      return result
    }
    
    return result
  }
  
  /**
   * 检查是否需要登录
   * @param {string} url 页面路径
   */
  requireAuth(url) {
    return routeGuards.requireAuth.some(route => url.startsWith(route))
  }
  
  /**
   * 检查是否仅限游客访问
   * @param {string} url 页面路径
   */
  isGuestOnly(url) {
    return routeGuards.guestOnly.some(route => url.startsWith(route))
  }
  
  /**
   * 检查是否需要特定菜单权限
   * @param {string} url 页面路径
   */
  requireMenuPermission(url) {
    return Object.keys(routeGuards.requireMenuPermission).some(route => url.startsWith(route))
  }
  
  /**
   * 检查是否需要特定角色
   * @param {string} url 页面路径
   */
  requireRole(url) {
    return Object.keys(routeGuards.requireRole).some(route => url.startsWith(route))
  }
  
  /**
   * 检查是否有菜单权限
   * @param {string} url 页面路径
   */
  hasMenuPermission(url) {
    const requiredPermissions = routeGuards.requireMenuPermission[url] || []
    return requiredPermissions.every(permission => this.authStore.hasMenuPermission(permission))
  }
  
  /**
   * 检查是否有角色
   * @param {string} url 页面路径
   */
  hasRole(url) {
    const requiredRoles = routeGuards.requireRole[url] || []
    return requiredRoles.some(role => this.authStore.hasRole(role))
  }
  
  /**
   * 页面跳转前检查
   * @param {object} options 跳转选项
   */
  beforeNavigate(options) {
    const result = this.checkAccess(options.url)
    
    if (!result.canAccess) {
      console.log(`页面访问被拒绝: ${options.url}, 原因: ${result.reason}`)
      
      // 显示提示
      if (result.reason === '需要登录') {
        uni.showToast({
          title: '请先登录',
          icon: 'none'
        })
        // 需要登录时仍然跳转
        if (result.redirect) {
          setTimeout(() => {
            if (result.redirect.startsWith('/pages/error/')) {
              uni.navigateTo({ url: result.redirect })
            } else {
              uni.reLaunch({ url: result.redirect })
            }
          }, 1500)
        }
        return false
      } else if (result.reason === '权限不足') {
        uni.showToast({
          title: '暂无访问权限',
          icon: 'none',
          duration: 2000
        })
        // 权限不足时不再跳转，允许继续访问
        return true
      }
      
      // 其他情况的重定向
      if (result.redirect) {
        setTimeout(() => {
          if (result.redirect.startsWith('/pages/error/')) {
            uni.navigateTo({ url: result.redirect })
          } else {
            uni.reLaunch({ url: result.redirect })
          }
        }, 1500)
      }
      
      return false
    }
    
    return true
  }
  
  /**
   * 页面显示前检查
   * @param {string} url 页面路径
   */
  beforeShow(url) {
    const result = this.checkAccess(url)
    
    if (!result.canAccess) {
      console.log(`页面显示被拒绝: ${url}, 原因: ${result.reason}`)
      
      // 显示提示
      if (result.reason === '需要登录') {
        uni.showToast({
          title: '请先登录',
          icon: 'none'
        })
        // 需要登录时仍然跳转
        if (result.redirect) {
          if (result.redirect.startsWith('/pages/error/')) {
            uni.navigateTo({ url: result.redirect })
          } else {
            uni.reLaunch({ url: result.redirect })
          }
        }
        return false
      } else if (result.reason === '权限不足') {
        uni.showToast({
          title: '暂无访问权限',
          icon: 'none',
          duration: 2000
        })
        // 权限不足时不再跳转，允许继续显示
        return true
      }
      
      // 其他情况的重定向
      if (result.redirect) {
        if (result.redirect.startsWith('/pages/error/')) {
          uni.navigateTo({ url: result.redirect })
        } else {
          uni.reLaunch({ url: result.redirect })
        }
      }
      
      return false
    }
    
    return true
  }
  
  /**
   * 检查登录状态并自动跳转
   */
  async checkLoginAndRedirect() {
    // 不再重复初始化认证状态，因为App.vue已经初始化过了
    if (!this.authStore.isLoggedIn) {
      // 检查是否有自动登录
      if (this.authStore.autoLoginEnabled) {
        try {
          const success = await this.authStore.silentLogin()
          if (!success) {
            this.redirectToLogin()
          }
        } catch (error) {
          console.error('自动登录失败:', error)
          this.redirectToLogin()
        }
      } else {
        this.redirectToLogin()
      }
    }
  }
  
  /**
   * 跳转到登录页
   */
  redirectToLogin() {
    const currentPages = getCurrentPages()
    const currentPage = currentPages[currentPages.length - 1]
    
    if (currentPage && currentPage.route !== 'pages/login/login') {
      uni.reLaunch({
        url: '/pages/login/login'
      })
    }
  }
  
  /**
   * 跳转到首页
   */
  redirectToHome() {
    uni.switchTab({
      url: '/pages/index/index'
    })
  }
  
  /**
   * 跳转到错误页
   * @param {number} code 错误码
   */
  redirectToError(code = 404) {
    uni.navigateTo({
      url: `/pages/error/${code}`
    })
  }
}

// 创建路由守卫实例
const routerGuard = new RouterGuard()

/**
 * 页面跳转拦截器
 */
uni.addInterceptor('navigateTo', {
  invoke(args) {
    return routerGuard.beforeNavigate(args)
  }
})

uni.addInterceptor('redirectTo', {
  invoke(args) {
    return routerGuard.beforeNavigate(args)
  }
})

uni.addInterceptor('reLaunch', {
  invoke(args) {
    return routerGuard.beforeNavigate(args)
  }
})

uni.addInterceptor('switchTab', {
  invoke(args) {
    return routerGuard.beforeNavigate(args)
  }
})

/**
 * 页面生命周期拦截器
 */
uni.addInterceptor('page', {
  onLoad(options) {
    const pages = getCurrentPages()
    const currentPage = pages[pages.length - 1]
    
    if (currentPage) {
      const url = `/${currentPage.route}`
      routerGuard.beforeShow(url)
    }
  }
})

export default routerGuard 